home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / vmstat / vmstat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-03  |  18.8 KB  |  600 lines
  1. /* 
  2.  * vmstat.c --
  3.  *
  4.  *    Statistics generation for the virtual memory module.
  5.  *
  6.  * Copyright (C) 1986 Regents of the University of California
  7.  * All rights reserved.
  8.  */
  9.  
  10. #ifndef lint
  11. static char rcsid[] = "$Header: /sprite/src/cmds/vmstat/RCS/vmstat.c,v 1.8 90/07/03 16:26:25 mendel Exp $ SPRITE (Berkeley)";
  12. #endif not lint
  13.  
  14. #include <vm.h>
  15. #include <vmStat.h>
  16. #include <kernel/vm.h>
  17. #include "/sprite/src/kernel/vm/vmInt.h"
  18. #include <option.h>
  19. #include <sys/time.h>
  20. #include <stdio.h>
  21.  
  22. /*
  23.  * Flags to command-line options:
  24.  */
  25. int    checkTime = -1;            /* If != -1 indicates how often to
  26.                      * print a line of stats.  0 means 
  27.                      * just print one line and quit, 
  28.                      * non-zero means print a line
  29.                      * every checkTime seconds. */
  30. int    printSegInfo = 0;        /* Non-zero means print info for
  31.                      * all segments. */
  32. int    whenToPrintHdr = 25;        /* Number of lines of stats after 
  33.                      * which to print the header. */
  34. int    faultThreshold = 0;        /* Number of page faults after which
  35.                      * to print line of stats. */
  36. int    pageOutThreshold = 0;        /* Number of page outs after which
  37.                      * to print line of stats. */
  38. int    relToLastPrint = 0;        /* Non-zero means print stats relative
  39.                      * to last time printed, not last
  40.                      * interval of lengh checkTime. */
  41. int    printMod = 0;            /* Non-zero means replace printing out
  42.                      * of kernel stack pages with number
  43.                      * of modified pages in memory. */
  44. int    maxTimes = -1;            /* Maximum number can skip printing
  45.                      * a line of info because of 
  46.                      * faultThreshold or pageOutThreshold.*/
  47. int    verbose = 0;            /* Print extra more obscure vm 
  48.                      * stats. */
  49.  
  50. Option optionArray[] = {
  51.     {OPT_TRUE, "s", (Address)&printSegInfo,
  52.     "Print out information about all in-use segments"},
  53.     {OPT_TRUE, "v", (Address)&verbose,
  54.     "Print out extra, more obscure vm statistics"},
  55.     {OPT_INT, "t", (Address)&checkTime,
  56.     "Print out incremental vm info at this interval"},
  57.     {OPT_INT, "T", (Address)&maxTimes,
  58.     "Maximum times skip printing because of -f or -p flags. Used with -t."},
  59.     {OPT_INT, "l", (Address)&whenToPrintHdr,
  60.       "Lines to print before should print header (default: 25). Used with -t."},
  61.     {OPT_INT, "f", (Address)&faultThreshold, 
  62.    "Page faults per second before print out info (default: 0).  Used with -t."},
  63.     {OPT_INT, "p", (Address) &pageOutThreshold,
  64.     "Page outs per second before print out info (default: 0).  Used with -t."},
  65.     {OPT_TRUE, "P", (Address)&relToLastPrint,
  66.  "Print out all info since last print, not since last interval. Used with -t."},
  67.     {OPT_TRUE, "m", (Address)&printMod,
  68.     "Print out number of modified pages, not kern stack pages.  Used with -t."},
  69. };
  70. int    numOptions = Opt_Number(optionArray);
  71.  
  72. #define    NUM_SEGMENTS    256
  73. Vm_Stat     vmStat;
  74.  
  75. int    kbPerPage;
  76.  
  77. /*
  78.  *----------------------------------------------------------------------
  79.  *
  80.  * main --
  81.  *
  82.  *    The main program for vmstat.
  83.  *
  84.  * Results:
  85.  *    None.
  86.  *
  87.  * Side effects:
  88.  *    Prints information on standard output.
  89.  *
  90.  *----------------------------------------------------------------------
  91.  */
  92. main(argc, argv)
  93.     int argc;
  94.     char *argv[];
  95. {
  96.     int        pageSize;
  97.  
  98.     (void)Opt_Parse(argc, argv, optionArray, numOptions, 0);
  99.     Vm_PageSize(&pageSize);
  100.     kbPerPage = pageSize / 1024;
  101.  
  102.     if (printSegInfo) {
  103.     PrintSegInfo();
  104.     } else if (checkTime == 0) {
  105.     PrintWide();
  106.     printf("\n");
  107.     } else if (checkTime == -1) {
  108.     PrintSummary();
  109.     } else {
  110.     while (1) {
  111.         PrintWide();
  112.         sleep(checkTime);
  113.     }
  114.     }
  115.     exit(0);
  116. }
  117.  
  118.  
  119. /*
  120.  *----------------------------------------------------------------------
  121.  *
  122.  * PrintSegInfo --
  123.  *
  124.  *    Print vm info about all segments.
  125.  *
  126.  * Results:
  127.  *    None.
  128.  *
  129.  * Side effects:
  130.  *    Prints information on standard output.
  131.  *
  132.  *----------------------------------------------------------------------
  133.  */
  134. PrintSegInfo()
  135. {
  136.     int            actCodePages = 0;
  137.     int            inactCodePages = 0;
  138.     int            actCodeSegs = 0;
  139.     int            inactCodeSegs = 0;
  140.     int            heapPages = 0;
  141.     int            heapSegs = 0;
  142.     int            stackPages = 0;
  143.     int            stackSegs = 0;
  144.     Vm_SegmentInfo    seg;
  145.     int            i;
  146.     char        *typePtr;
  147.     char        *fileNamePtr;
  148.     ReturnStatus    status;
  149.  
  150.     printf("%-10s%-10s%-10s%-10s%-10s%s\n\n", "SEG-NUM", "TYPE",
  151.         "  SIZE", "RES-SIZE", "NUM-REFS", "OBJECT-FILE-NAME");
  152.     for (i = 1; i < NUM_SEGMENTS; i++) {
  153.     fileNamePtr = " ";
  154.     status = Vm_GetSegInfo(NULL, i, sizeof(Vm_SegmentInfo), &seg);
  155.     if (status != SUCCESS) {
  156.         (void) fprintf(stderr,
  157.                "Couldn't read segment info for segment %d: %s\n",
  158.                i,  Stat_GetMsg(status));
  159.         return;
  160.     }
  161.     if (seg.flags & VM_SEG_FREE) {
  162.         continue;
  163.     }
  164.     switch (seg.type) {
  165.         case VM_CODE:
  166.             if (seg.flags & VM_SEG_INACTIVE) {
  167.             typePtr = "Inactive";
  168.             inactCodePages += seg.resPages;
  169.             inactCodeSegs++;
  170.         } else {
  171.             typePtr = "Code";
  172.             actCodePages += seg.resPages;
  173.             actCodeSegs++;
  174.         }
  175.         fileNamePtr = seg.objFileName;
  176.         seg.objFileName[VM_OBJ_FILE_NAME_LENGTH - 1] = '\0';
  177.         break;
  178.         case VM_HEAP:
  179.         typePtr = "Heap";
  180.         heapPages += seg.resPages;
  181.         heapSegs++;
  182.         break;
  183.         case VM_STACK:
  184.         typePtr = "Stack";
  185.         stackPages += seg.resPages;
  186.         stackSegs++;
  187.         break;
  188.     }
  189.     printf("%-10d%-10s   %-7d   %-7d   %-7d%s\n",
  190.                i, typePtr,seg.numPages * kbPerPage,
  191.                seg.resPages * kbPerPage, seg.refCount, fileNamePtr);
  192.     }
  193.     printf("\n%-20s%-15s%-15s\n\n", "TYPE", "NUM-SEGS", "RES-SIZE");
  194.     printf("%-20s%-15d%-15d\n", "Active-code", actCodeSegs, actCodePages);
  195.     printf("%-20s%-15d%-15d\n", "Inactive-code", inactCodeSegs,
  196.          inactCodePages);
  197.     printf("%-20s%-15d%-15d\n", "Heap", heapSegs, heapPages);
  198.     printf("%-20s%-15d%-15d\n", "Stack", stackSegs, stackPages);
  199.     printf("%-20s%-15d%-15d\n", "TOTAL", 
  200.          actCodeSegs + inactCodeSegs + heapSegs + stackSegs,
  201.      (actCodePages + inactCodePages + heapPages + stackPages) * kbPerPage);
  202. }
  203.  
  204. static Vm_Stat    prevStat;
  205.  
  206.  
  207. /*
  208.  *----------------------------------------------------------------------
  209.  *
  210.  * PrintWide --
  211.  *
  212.  *    Print a one summary of vm stats.
  213.  *
  214.  * Results:
  215.  *    None.
  216.  *
  217.  * Side effects:
  218.  *    Prints information on standard output.
  219.  *
  220.  *----------------------------------------------------------------------
  221.  */
  222. PrintWide()
  223. {
  224.     static    int    numLines = 0;
  225.     static    int    numCalls = 0;
  226.     Vm_Stat        vmStat;
  227.  
  228.     (void)Vm_Cmd(VM_GET_STATS, &vmStat);
  229.  
  230.     if (checkTime != 0 && numCalls != maxTimes) {
  231.     if ((vmStat.totalFaults - prevStat.totalFaults) / checkTime < 
  232.         faultThreshold &&
  233.         (vmStat.pagesWritten - prevStat.pagesWritten) / checkTime < 
  234.             pageOutThreshold) {
  235.         if (relToLastPrint) {
  236.         bcopy((Address)&vmStat, (Address)&prevStat, sizeof(Vm_Stat));
  237.         }
  238.         numCalls++;
  239.         return;
  240.     }
  241.     }
  242.     numCalls = 0;
  243.     if (numLines % whenToPrintHdr == 0) {
  244.     if (numLines > 0) {
  245.         printf("\n");
  246.     }
  247.     if (printMod) {
  248.     printf("%-8s%-8s%-8s%-8s%-8s%-8s%-8s%-8s%-8s%-8s",
  249.         " AVAIL", "  FREE", "  USER", " MOD%", " KMEM",
  250.         "  FS$", "PF-NUM",
  251.         "PF-SWP", " PF-FS", " POUTS");
  252.     } else {
  253.         printf("%-8s%-8s%-8s%-8s%-8s%-8s%-8s%-8s%-8s%-8s",
  254.         " AVAIL", "  FREE", "  USER",  " KMEM",
  255.         " KSTK", "  FS$", "PF-NUM",
  256.         "PF-SWP", " PF-FS", " POUTS");
  257.     }
  258.     }
  259.     numLines++;
  260.  
  261.     if (printMod) {
  262.     int    numModifiedPages;
  263.  
  264.     (void)Vm_Cmd(VM_COUNT_DIRTY_PAGES, &numModifiedPages);
  265.     printf("\n%6d%8d%8d%8.2f%7d%8d%9d%8d%8d%8d",
  266.          vmStat.numPhysPages * kbPerPage,
  267.          vmStat.numFreePages * kbPerPage, 
  268.          (vmStat.numDirtyPages + vmStat.numUserPages) * kbPerPage,
  269.          (float)numModifiedPages /
  270.            (float)(vmStat.numDirtyPages + vmStat.numUserPages) * 100.0,
  271.          (vmStat.kernMemPages + vmStat.kernStackPages) * kbPerPage, 
  272.          (vmStat.fsMap - vmStat.fsUnmap) * kbPerPage,
  273.          vmStat.totalFaults - prevStat.totalFaults, 
  274.          vmStat.psFilled - prevStat.psFilled,
  275.          vmStat.fsFilled - prevStat.fsFilled,
  276.          vmStat.pagesWritten - prevStat.pagesWritten);
  277.     } else {
  278.     printf("\n%6d%8d%8d%7d%8d%8d%9d%8d%8d%8d",
  279.          vmStat.numPhysPages * kbPerPage,
  280.          vmStat.numFreePages * kbPerPage, 
  281.          (vmStat.numDirtyPages + vmStat.numUserPages) * kbPerPage,
  282.          vmStat.kernMemPages * kbPerPage, 
  283.          vmStat.kernStackPages * kbPerPage,
  284.          (vmStat.fsMap - vmStat.fsUnmap) * kbPerPage,
  285.          vmStat.totalFaults - prevStat.totalFaults, 
  286.          vmStat.psFilled - prevStat.psFilled,
  287.          vmStat.fsFilled - prevStat.fsFilled,
  288.          vmStat.pagesWritten - prevStat.pagesWritten);
  289.     }
  290.     bcopy((Address)&vmStat, (Address)&prevStat, sizeof(Vm_Stat));
  291.     fflush(stdout);
  292. }
  293.  
  294.  
  295. /*
  296.  *----------------------------------------------------------------------
  297.  *
  298.  * PrintSummary --
  299.  *
  300.  *    Print a verbose summary of all vm statistics.
  301.  *
  302.  * Results:
  303.  *    None.
  304.  *
  305.  * Side effects:
  306.  *    Prints information on standard output.
  307.  *
  308.  *----------------------------------------------------------------------
  309.  */
  310. PrintSummary()
  311. {
  312.     int            actCodePages = 0;
  313.     int            inactCodePages = 0;
  314.     int            actCodeSegs = 0;
  315.     int            inactCodeSegs = 0;
  316.     int            heapPages = 0;
  317.     int            heapSegs = 0;
  318.     int            stackPages = 0;
  319.     int            stackSegs = 0;
  320.     Vm_SegmentInfo    seg;
  321.     int            i;
  322.     Vm_Stat         vmStat;
  323.     int            totPages;
  324.     int            inusePages;
  325.     int            numModifiedPages;
  326.     int            totPercent;
  327.     int            totFaults;
  328.     int            heapPercent;
  329.     int            stkPercent;
  330.     int            quickPercent;    
  331.     int            totHits;
  332.     int            totPrefetches;
  333.     int            hitPct;
  334.     ReturnStatus    status;
  335.  
  336.     Vm_Cmd(VM_GET_STATS, &vmStat);
  337.     Vm_Cmd(VM_COUNT_DIRTY_PAGES, &numModifiedPages);
  338.     for (i = 1; i < NUM_SEGMENTS; i++) {
  339.     status = Vm_GetSegInfo(NULL, i, sizeof(Vm_SegmentInfo), &seg);
  340.     if (status != SUCCESS) {
  341.         (void) fprintf(stderr,
  342.                "Couldn't read segment info for segment %d: %s\n",
  343.                i,  Stat_GetMsg(status));
  344.         return;
  345.     }
  346.     if (seg.flags & VM_SEG_FREE) {
  347.         continue;
  348.     }
  349.     switch (seg.type) {
  350.         case VM_CODE:
  351.             if (seg.flags & VM_SEG_INACTIVE) {
  352.             inactCodePages += seg.resPages;
  353.             inactCodeSegs++;
  354.         } else {
  355.             actCodePages += seg.resPages;
  356.             actCodeSegs++;
  357.         }
  358.         break;
  359.         case VM_HEAP:
  360.         heapPages += seg.resPages;
  361.         heapSegs++;
  362.         break;
  363.         case VM_STACK:
  364.         stackPages += seg.resPages;
  365.         stackSegs++;
  366.         break;
  367.     }
  368.     }
  369.     printf("MEMORY STATS:\n");
  370.     printf("\tPage Size:\t%-8d\n", 1024 * kbPerPage);
  371.     printf("\tMemory Size:\t%-8d\n", vmStat.numPhysPages * kbPerPage);
  372.     printf("\tKernel Memory:\t%-8d (Code+Data=%d Stacks=%d Reserved=%d)\n",
  373.          (vmStat.kernMemPages + vmStat.kernStackPages +
  374.             vmStat.numReservePages) * kbPerPage,
  375.          vmStat.kernMemPages * kbPerPage, 
  376.          vmStat.kernStackPages * kbPerPage,
  377.          vmStat.numReservePages * kbPerPage);
  378.     inusePages = vmStat.numDirtyPages + vmStat.numUserPages;
  379.     printf("\tUser Memory:\t%-8d (Dirty=%d Clean=%d)\n",
  380.         inusePages * kbPerPage, 
  381.         numModifiedPages * kbPerPage, 
  382.         (inusePages - numModifiedPages) * kbPerPage);
  383.     printf("\tFS Memory:\t%-8d (Min=%d Max=%d)\n", 
  384.         (vmStat.fsMap - vmStat.fsUnmap) * kbPerPage, 
  385.         vmStat.minFSPages * kbPerPage,
  386.         vmStat.maxFSPages * kbPerPage);
  387.     printf("\tFree Memory:\t%d\n", vmStat.numFreePages * kbPerPage);
  388.     if (verbose) {
  389.     printf("\tMod page stats:\tPot-mod=%d Not-mod=%d Not-hard-mod=%d\n",
  390.         vmStat.potModPages, vmStat.notModPages, vmStat.notHardModPages);
  391.     }
  392.     printf("SEGMENT STATS:\n");
  393.     printf("\tAct-code:\tNum-segs=%-3d Res-size=%d\n", actCodeSegs,
  394.                           actCodePages * kbPerPage);
  395.     printf("\tInact-code:\tNum-segs=%-3d Res-size=%d\n", inactCodeSegs,
  396.                           inactCodePages * kbPerPage);
  397.     printf("\tHeap:\t\tNum-segs=%-3d Res-size=%d\n", heapSegs, 
  398.                           heapPages * kbPerPage);
  399.     printf("\tStack:\t\tNum-segs=%-3d Res-size=%d\n", stackSegs, 
  400.                           stackPages*kbPerPage);
  401.     printf("FAULT STATS:\n");
  402.     printf("\tTotal:\t\t%d\n", vmStat.totalFaults);
  403.     printf("\tFault-type:\tZero=%-6d FS=%-8d Swap=%-9d Quick=%d\n", 
  404.          vmStat.zeroFilled, vmStat.fsFilled,
  405.          vmStat.psFilled, vmStat.quickFaults -
  406.         (vmStat.numCOWStkFaults + vmStat.numCOWHeapFaults +
  407.          vmStat.numCORStkFaults + vmStat.numCORHeapFaults));
  408.     printf("\t\t\tCOW=%-7d COR=%-7d COR-mod=%-5d\n",
  409.          vmStat.numCOWStkFaults + vmStat.numCOWHeapFaults,
  410.          vmStat.numCORStkFaults + vmStat.numCORHeapFaults,
  411.          vmStat.numCORCOWStkFaults + vmStat.numCORCOWHeapFaults);
  412.     printf("\tSeg-type:\tCode=%-6d Heap=%-6d Stack=%-6d\n", 
  413.          vmStat.codeFaults, vmStat.heapFaults, vmStat.stackFaults);
  414.     printf("\tCollisions:\t%d\n", vmStat.collFaults);
  415.     printf("PAGE-OUTS:\n");
  416.     printf("\tPages written:\t%d\n", vmStat.pagesWritten);
  417.     if (verbose) {
  418.     printf("\tClean Wait:\t%d\n", vmStat.cleanWait);
  419.     printf("\tCleaner starts:\t%d\n", vmStat.pageoutWakeup);
  420.     }
  421.     printf("COPY-ON-WRITE:\n");
  422.     totPages = vmStat.numCOWStkPages + vmStat.numCOWHeapPages;
  423.     totFaults = vmStat.numCOWStkFaults + vmStat.numCOWHeapFaults;
  424.     if (vmStat.numCOWHeapPages > 0) {
  425.     heapPercent = 100.0 * ((float)vmStat.numCOWHeapFaults / 
  426.                       vmStat.numCOWHeapPages);
  427.     } else {
  428.     heapPercent = 0;
  429.     }
  430.     if (vmStat.numCOWStkPages > 0) {
  431.     stkPercent = 100.0 * ((float)vmStat.numCOWStkFaults / 
  432.                       vmStat.numCOWStkPages);
  433.     } else {
  434.     stkPercent = 0;
  435.     }
  436.     if (totPages > 0) {
  437.     totPercent = 100.0 * ((float)totFaults / totPages);
  438.     } else {
  439.     totPercent = 0;
  440.     }
  441.     if (totFaults > 0) {
  442.     quickPercent = 100.0 * ((float)vmStat.quickCOWFaults / totFaults);
  443.     } else {
  444.     quickPercent = 0;
  445.     }
  446.     printf("\tCOW:\t\tHeap (%d/%d)=%d%%\tStack (%d/%d)=%d%%\n",
  447.         vmStat.numCOWHeapFaults, vmStat.numCOWHeapPages, heapPercent,
  448.         vmStat.numCOWStkFaults, vmStat.numCOWStkPages, stkPercent);
  449.     printf("\t\t\tTot  (%d/%d)=%d%%\tQuick (%d/%d)=%d%%\n",
  450.         totFaults, totPages, totPercent,
  451.         vmStat.quickCOWFaults, totFaults, quickPercent);
  452.     /*
  453.      * Copy on reference.
  454.      */
  455.     totPages = vmStat.numCORStkPages + vmStat.numCORHeapPages;
  456.     totFaults = vmStat.numCORStkFaults + vmStat.numCORHeapFaults;
  457.     if (vmStat.numCORHeapPages > 0) {
  458.     heapPercent = 100.0 * ((float)vmStat.numCORHeapFaults / 
  459.                       vmStat.numCORHeapPages);
  460.     } else {
  461.     heapPercent = 0;
  462.     }
  463.     if (vmStat.numCORStkPages > 0) {
  464.     stkPercent = 100.0 * ((float)vmStat.numCORStkFaults / 
  465.                       vmStat.numCORStkPages);
  466.     } else {
  467.     stkPercent = 0;
  468.     }
  469.     if (totPages > 0) {
  470.     totPercent = 100.0 * ((float)totFaults / totPages);
  471.     } else {
  472.     totPercent = 0;
  473.     }
  474.     printf("\tCOR:\t\tHeap (%d/%d)=%d%%\tStack (%d/%d)=%d%%\n",
  475.         vmStat.numCORHeapFaults, vmStat.numCORHeapPages, heapPercent,
  476.         vmStat.numCORStkFaults, vmStat.numCORStkPages, stkPercent,
  477.         totFaults, totPages, totPercent);
  478.     printf("\t\t\tTot  (%d/%d)=%d%%\n",
  479.         totFaults, totPages, totPercent);
  480.     totPages = vmStat.numCORStkFaults + vmStat.numCORHeapFaults;
  481.     totFaults = vmStat.numCORCOWStkFaults + vmStat.numCORCOWHeapFaults;
  482.     if (vmStat.numCORCOWHeapFaults > 0) {
  483.     heapPercent = 100.0 * ((float)vmStat.numCORCOWHeapFaults / 
  484.                       vmStat.numCORHeapFaults);
  485.     } else {
  486.     heapPercent = 0;
  487.     }
  488.     if (vmStat.numCORCOWStkFaults > 0) {
  489.     stkPercent = 100.0 * ((float)vmStat.numCORCOWStkFaults / 
  490.                       vmStat.numCORStkFaults);
  491.     } else {
  492.     stkPercent = 0;
  493.     }
  494.     if (totPages > 0) {
  495.     totPercent = 100.0 * ((float)totFaults / totPages);
  496.     } else {
  497.     totPercent = 0;
  498.     }
  499.     if (vmStat.numCORCOWHeapFaults > 0) {
  500.     printf("\tCOR-mod:\tHeap (%d/%d)=%d%%\tStack (%d/%d)=%d%%\n",
  501.         vmStat.numCORCOWHeapFaults, vmStat.numCORHeapFaults, heapPercent,
  502.         vmStat.numCORCOWStkFaults, vmStat.numCORStkFaults, stkPercent,
  503.         vmStat.numCORCOWHeapFaults + vmStat.numCORCOWStkFaults);
  504.     printf("\t\t\tTot  (%d/%d)=%d%%\n",
  505.         vmStat.numCORCOWHeapFaults + vmStat.numCORCOWStkFaults,
  506.         vmStat.numCORHeapFaults + vmStat.numCORStkFaults, totPercent);
  507.     }
  508.     if (verbose) {
  509.     printf("ALLOCATION STATS:\n");
  510.     printf("\tVm allocs:\t%d\t(Free=%d From-FS=%d From-alloc-list=%d)\n",
  511.          vmStat.numAllocs, vmStat.gotFreePage, vmStat.gotPageFromFS, 
  512.          vmStat.pageAllocs);
  513.     printf("\tVM-FS stats:\tFS-asked=%d Had-free-page=%d\n",
  514.          vmStat.fsAsked, vmStat.haveFreePage);
  515.     printf("\t\t\tFS-map=%d FS-unmap=%d\n", vmStat.fsMap, vmStat.fsUnmap);
  516.     printf("\tList searches:\t%d (Free=%d In-use=%d)\n",
  517.          vmStat.numListSearches, vmStat.usedFreePage, 
  518.          vmStat.numListSearches - vmStat.usedFreePage);
  519.     printf("\tExtra-searches:\t%d (Lock=%d Ref=%d Dirty=%d)\n",
  520.          vmStat.lockSearched + vmStat.refSearched + vmStat.dirtySearched,
  521.          vmStat.lockSearched, vmStat.refSearched, vmStat.dirtySearched);
  522.     printf("LIST STATS:\n");
  523.     printf("\tAlloc-list:\t%d\n", vmStat.numUserPages);
  524.     printf("\tDirty-list:\t%d\n", vmStat.numDirtyPages);
  525.     printf("\tFree-list:\t%d\n", vmStat.numFreePages);
  526.     printf("\tReserve-list:\t%d\n", vmStat.numReservePages);
  527. #ifdef notdef
  528.     totPrefetches = vmStat.codePrefetches + vmStat.heapFSPrefetches +
  529.             vmStat.heapSwapPrefetches + vmStat.stackPrefetches;
  530.     if (totPrefetches > 0) {
  531.         totHits = vmStat.codePrefetchHits + vmStat.heapFSPrefetchHits +
  532.               vmStat.heapSwapPrefetchHits + vmStat.stackPrefetchHits;
  533.         printf("Prefetch stats:\n");
  534.         if (vmStat.codePrefetches > 0) {
  535.         hitPct = 100 * ((float)vmStat.codePrefetchHits / 
  536.                 (float)vmStat.codePrefetches);
  537.         printf("    code (%d/%d)=%d%%\n",
  538.             vmStat.codePrefetchHits, vmStat.codePrefetches, hitPct);
  539.         }
  540.         if (vmStat.heapFSPrefetches > 0) {
  541.         hitPct = 100 * ((float)vmStat.heapFSPrefetchHits / 
  542.                 (float)vmStat.heapFSPrefetches);
  543.         printf("    heap-fs (%d/%d)=%d%%\n",
  544.             vmStat.heapFSPrefetchHits, vmStat.heapFSPrefetches, hitPct);
  545.         }
  546.         if (vmStat.heapSwapPrefetches > 0) {
  547.         hitPct = 100 * ((float)vmStat.heapSwapPrefetchHits / 
  548.                 (float)vmStat.heapSwapPrefetches);
  549.         printf("    heap-swp (%d/%d)=%d%%\n",
  550.             vmStat.heapSwapPrefetchHits, vmStat.heapSwapPrefetches, 
  551.             hitPct);
  552.         }
  553.         if (vmStat.stackPrefetches > 0) {
  554.         hitPct = 100 * ((float)vmStat.stackPrefetchHits / 
  555.                 (float)vmStat.stackPrefetches);
  556.         printf("    stack (%d/%d)=%d%%\n",
  557.             vmStat.stackPrefetchHits, vmStat.stackPrefetches, hitPct);
  558.         }
  559.         hitPct = 100 * ((float)totHits / (float)totPrefetches);
  560.         printf("    total (%d/%d)=%d%%\n",
  561.             totHits, totPrefetches, hitPct);
  562.         printf("    aborts=   %d\n", vmStat.prefetchAborts);
  563.     }
  564. #endif
  565.     printf("PAGE MAPPING STATS:\n");
  566.     printf("\tMap page wait:\t%d\n", vmStat.mapPageWait);
  567. #ifdef sun2
  568.     printf("HARDWARE_STATS:\n");
  569.     printf("\tCtxts stolen:\t%d\n", vmStat.machDepStat.stealContext);
  570.     printf("\tPmegs stolen:\t%d\n", vmStat.machDepStat.stealPmeg);
  571. #endif
  572. #ifdef sun3
  573.     printf("HARDWARE_STATS:\n");
  574.     printf("\tCtxts stolen:\t%d\n", vmStat.machDepStat.stealContext);
  575.     printf("\tPmegs stolen:\t%d\n", vmStat.machDepStat.stealPmeg);
  576. #endif
  577. #ifdef sun4
  578.     printf("HARDWARE_STATS:\n");
  579.     printf("\tCtxts stolen:\t%d\n", vmStat.machDepStat.stealContext);
  580.     printf("\tPmegs stolen:\t%d\n", vmStat.machDepStat.stealPmeg);
  581. #endif
  582. #ifdef spur
  583.     printf("HARDWARE_STATS:\n");
  584.     printf("\tRef bit faults:\t%d\n", vmStat.machDepStat.refBitFaults);
  585.     printf("\tDirty bit faults:\t%d\n", vmStat.machDepStat.dirtyBitFaults);
  586. #endif
  587. #ifdef ds3100
  588.     printf("HARDWARE_STATS:\n");
  589. #ifdef notdef 
  590.     /* 
  591.      * Not currently implemented by kernel.
  592.      */
  593.     printf("\tTlb entries stolen:\t%d\n", vmStat.machDepStat.stealTLB);
  594. #endif
  595.     printf("\tPids stolen:\t%d\n", vmStat.machDepStat.stealPID);
  596. #endif
  597.     }
  598. }
  599.  
  600.